Termination w.r.t. Q of the following Term Rewriting System could not be shown:

Q restricted rewrite system:
The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

Q is empty.


QTRS
  ↳ AAECC Innermost

Q restricted rewrite system:
The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

Q is empty.

We have applied [19,8] to switch to innermost. The TRS R 1 is

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x

The TRS R 2 is

f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The signature Sigma is {f}

↳ QTRS
  ↳ AAECC Innermost
QTRS
      ↳ DependencyPairsProof

Q restricted rewrite system:
The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))


Using Dependency Pairs [1,15] we result in the following initial DP problem:
Q DP problem:
The TRS P consists of the following rules:

-1(s(x), s(y)) → -1(x, y)
F(s(x)) → -1(p(*(s(x), s(x))), *(s(x), s(x)))
F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x))))
F(s(x)) → P(*(s(x), s(x)))
F(s(x)) → *1(s(x), s(x))
+1(s(x), y) → +1(x, y)
*1(x, s(y)) → *1(x, y)
*1(x, s(y)) → +1(x, *(x, y))

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
QDP
          ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

-1(s(x), s(y)) → -1(x, y)
F(s(x)) → -1(p(*(s(x), s(x))), *(s(x), s(x)))
F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x))))
F(s(x)) → P(*(s(x), s(x)))
F(s(x)) → *1(s(x), s(x))
+1(s(x), y) → +1(x, y)
*1(x, s(y)) → *1(x, y)
*1(x, s(y)) → +1(x, *(x, y))

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 4 SCCs with 4 less nodes.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
QDP
                ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+1(s(x), y) → +1(x, y)

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+1(s(x), y) → +1(x, y)

R is empty.
The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

+1(s(x), y) → +1(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
QDP
                ↳ UsableRulesProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*1(x, s(y)) → *1(x, y)

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*1(x, s(y)) → *1(x, y)

R is empty.
The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ QDPSizeChangeProof
              ↳ QDP
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

*1(x, s(y)) → *1(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
QDP
                ↳ UsableRulesProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-1(s(x), s(y)) → -1(x, y)

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-1(s(x), s(y)) → -1(x, y)

R is empty.
The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ QDPSizeChangeProof
              ↳ QDP

Q DP problem:
The TRS P consists of the following rules:

-1(s(x), s(y)) → -1(x, y)

R is empty.
Q is empty.
We have to consider all minimal (P,Q,R)-chains.
By using the subterm criterion [20] together with the size-change analysis [32] we have proven that there are no infinite chains for this DP problem.

From the DPs we obtained the following set of size-change graphs:



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
QDP
                ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x))))

The TRS R consists of the following rules:

-(x, 0) → x
-(s(x), s(y)) → -(x, y)
+(0, y) → y
+(s(x), y) → s(+(x, y))
*(x, 0) → 0
*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
f(s(x)) → f(-(p(*(s(x), s(x))), *(s(x), s(x))))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
QDP
                    ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
-(x, 0) → x
-(s(x), s(y)) → -(x, y)
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))
f(s(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

f(s(x0))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
QDP
                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
-(x, 0) → x
-(s(x), s(y)) → -(x, y)
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(x)) → F(-(p(*(s(x), s(x))), *(s(x), s(x)))) at position [0,0,0] we obtained the following new rules:

F(s(x)) → F(-(p(+(s(x), *(s(x), x))), *(s(x), s(x))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
QDP
                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(p(+(s(x), *(s(x), x))), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
-(x, 0) → x
-(s(x), s(y)) → -(x, y)
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(x)) → F(-(p(+(s(x), *(s(x), x))), *(s(x), s(x)))) at position [0,0,0] we obtained the following new rules:

F(s(x)) → F(-(p(s(+(x, *(s(x), x)))), *(s(x), s(x))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
QDP
                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(p(s(+(x, *(s(x), x)))), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
-(x, 0) → x
-(s(x), s(y)) → -(x, y)
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(x)) → F(-(p(s(+(x, *(s(x), x)))), *(s(x), s(x)))) at position [0,0] we obtained the following new rules:

F(s(x)) → F(-(+(x, *(s(x), x)), *(s(x), s(x))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
QDP
                                    ↳ UsableRulesProof

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(+(x, *(s(x), x)), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
p(s(x)) → x
-(x, 0) → x
-(s(x), s(y)) → -(x, y)
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))

We have to consider all minimal (P,Q,R)-chains.
As all Q-normal forms are R-normal forms we are in the innermost case. Hence, by the usable rules processor [15] we can delete all non-usable rules [17] from R.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
QDP
                                        ↳ QReductionProof

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(+(x, *(s(x), x)), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))
p(s(x0))

We have to consider all minimal (P,Q,R)-chains.
We deleted the following terms from Q as each root-symbol of these terms does neither occur in P nor in R.

p(s(x0))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
QDP
                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(+(x, *(s(x), x)), *(s(x), s(x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(x)) → F(-(+(x, *(s(x), x)), *(s(x), s(x)))) at position [0,1] we obtained the following new rules:

F(s(x)) → F(-(+(x, *(s(x), x)), +(s(x), *(s(x), x))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
QDP
                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(+(x, *(s(x), x)), +(s(x), *(s(x), x))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(x)) → F(-(+(x, *(s(x), x)), +(s(x), *(s(x), x)))) at position [0,1] we obtained the following new rules:

F(s(x)) → F(-(+(x, *(s(x), x)), s(+(x, *(s(x), x)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
QDP
                                                    ↳ Narrowing

Q DP problem:
The TRS P consists of the following rules:

F(s(x)) → F(-(+(x, *(s(x), x)), s(+(x, *(s(x), x)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By narrowing [15] the rule F(s(x)) → F(-(+(x, *(s(x), x)), s(+(x, *(s(x), x))))) at position [0] we obtained the following new rules:

F(s(0)) → F(-(+(0, *(s(0), 0)), s(+(0, 0))))
F(s(s(x1))) → F(-(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(+(s(x1), *(s(s(x1)), s(x1))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
QDP
                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0)))))
F(s(s(x1))) → F(-(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(0)) → F(-(+(0, *(s(0), 0)), s(+(0, 0))))
F(s(s(x1))) → F(-(+(s(x1), *(s(s(x1)), s(x1))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(0)) → F(-(+(0, *(s(0), 0)), s(+(0, 0)))) at position [0,0] we obtained the following new rules:

F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
QDP
                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))
F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0)))))
F(s(s(x1))) → F(-(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(+(s(x1), *(s(s(x1)), s(x1))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))), s(+(s(x1), *(s(s(x1)), s(x1)))))) at position [0,0] we obtained the following new rules:

F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
QDP
                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))
F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0)))))
F(s(s(x1))) → F(-(+(s(x1), *(s(s(x1)), s(x1))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(s(x1), *(s(s(x1)), s(x1))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))) at position [0,0] we obtained the following new rules:

F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
QDP
                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))
F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(0)) → F(-(+(0, 0), s(+(0, *(s(0), 0))))) at position [0,0] we obtained the following new rules:

F(s(0)) → F(-(0, s(+(0, *(s(0), 0)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
QDP
                                                                        ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(0, s(+(0, *(s(0), 0)))))
F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))
F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
QDP
                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(0)) → F(-(*(s(0), 0), s(+(0, 0))))
F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(0)) → F(-(*(s(0), 0), s(+(0, 0)))) at position [0,0] we obtained the following new rules:

F(s(0)) → F(-(0, s(+(0, 0))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
QDP
                                                                                ↳ DependencyGraphProof

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(0)) → F(-(0, s(+(0, 0))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
The approximation of the Dependency Graph [15,17,22] contains 1 SCC with 1 less node.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
QDP
                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))), s(+(s(x1), *(s(s(x1)), s(x1)))))) at position [0] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), *(s(s(x1)), s(x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
QDP
                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), *(s(s(x1)), s(x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(s(+(x1, *(s(s(x1)), s(x1)))), s(+(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))) at position [0] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, *(s(s(x1)), s(x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
QDP
                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, *(s(s(x1)), s(x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))
F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), *(s(s(x1)), s(x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), *(s(s(x1)), s(x1))))) at position [0,0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), *(s(s(x1)), s(x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
QDP
                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), *(s(s(x1)), s(x1)))))
F(s(s(x1))) → F(-(+(x1, *(s(s(x1)), s(x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, *(s(s(x1)), s(x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))) at position [0,0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
QDP
                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), *(s(s(x1)), s(x1)))))
F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), *(s(s(x1)), s(x1))))) at position [0,0,1,0] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), *(s(s(x1)), s(x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
QDP
                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), *(s(s(x1)), s(x1)))))
F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, +(s(s(x1)), *(s(s(x1)), x1))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))) at position [0,0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
QDP
                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), *(s(s(x1)), s(x1)))))
F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), *(s(s(x1)), s(x1))))) at position [0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, *(s(s(x1)), s(x1))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
QDP
                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(+(s(x1), *(s(s(x1)), x1)))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))) at position [0,0,1,0] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
QDP
                                                                                                                    ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, *(s(s(x1)), s(x1))))))
F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, *(s(s(x1)), s(x1)))))) at position [0,1,0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, +(s(s(x1)), *(s(s(x1)), x1))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Rewriting
QDP
                                                                                                                        ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, +(s(s(x1)), *(s(s(x1)), x1))))))
F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1)))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), +(s(x1), +(s(s(x1)), *(s(s(x1)), x1))))) at position [0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, +(s(s(x1)), *(s(s(x1)), x1))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Rewriting
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
QDP
                                                                                                                            ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, +(s(s(x1)), *(s(s(x1)), x1))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, +(s(s(x1)), *(s(s(x1)), x1)))))) at position [0,1,0,1] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(+(s(x1), *(s(s(x1)), x1)))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Rewriting
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
QDP
                                                                                                                                ↳ Rewriting

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(+(s(x1), *(s(s(x1)), x1)))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
By rewriting [15] the rule F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(+(s(x1), *(s(s(x1)), x1))))))) at position [0,1,0,1,0] we obtained the following new rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(s(+(x1, *(s(s(x1)), x1))))))))



↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Rewriting
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Rewriting
QDP
                                                                                                                                    ↳ MNOCProof

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(s(+(x1, *(s(s(x1)), x1))))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

The set Q consists of the following terms:

-(x0, 0)
-(s(x0), s(x1))
+(0, x0)
+(s(x0), x1)
*(x0, 0)
*(x0, s(x1))

We have to consider all minimal (P,Q,R)-chains.
We use the modular non-overlap check [17] to decrease Q to the empty set.

↳ QTRS
  ↳ AAECC Innermost
    ↳ QTRS
      ↳ DependencyPairsProof
        ↳ QDP
          ↳ DependencyGraphProof
            ↳ AND
              ↳ QDP
              ↳ QDP
              ↳ QDP
              ↳ QDP
                ↳ UsableRulesProof
                  ↳ QDP
                    ↳ QReductionProof
                      ↳ QDP
                        ↳ Rewriting
                          ↳ QDP
                            ↳ Rewriting
                              ↳ QDP
                                ↳ Rewriting
                                  ↳ QDP
                                    ↳ UsableRulesProof
                                      ↳ QDP
                                        ↳ QReductionProof
                                          ↳ QDP
                                            ↳ Rewriting
                                              ↳ QDP
                                                ↳ Rewriting
                                                  ↳ QDP
                                                    ↳ Narrowing
                                                      ↳ QDP
                                                        ↳ Rewriting
                                                          ↳ QDP
                                                            ↳ Rewriting
                                                              ↳ QDP
                                                                ↳ Rewriting
                                                                  ↳ QDP
                                                                    ↳ Rewriting
                                                                      ↳ QDP
                                                                        ↳ DependencyGraphProof
                                                                          ↳ QDP
                                                                            ↳ Rewriting
                                                                              ↳ QDP
                                                                                ↳ DependencyGraphProof
                                                                                  ↳ QDP
                                                                                    ↳ Rewriting
                                                                                      ↳ QDP
                                                                                        ↳ Rewriting
                                                                                          ↳ QDP
                                                                                            ↳ Rewriting
                                                                                              ↳ QDP
                                                                                                ↳ Rewriting
                                                                                                  ↳ QDP
                                                                                                    ↳ Rewriting
                                                                                                      ↳ QDP
                                                                                                        ↳ Rewriting
                                                                                                          ↳ QDP
                                                                                                            ↳ Rewriting
                                                                                                              ↳ QDP
                                                                                                                ↳ Rewriting
                                                                                                                  ↳ QDP
                                                                                                                    ↳ Rewriting
                                                                                                                      ↳ QDP
                                                                                                                        ↳ Rewriting
                                                                                                                          ↳ QDP
                                                                                                                            ↳ Rewriting
                                                                                                                              ↳ QDP
                                                                                                                                ↳ Rewriting
                                                                                                                                  ↳ QDP
                                                                                                                                    ↳ MNOCProof
QDP

Q DP problem:
The TRS P consists of the following rules:

F(s(s(x1))) → F(-(+(x1, s(s(+(x1, *(s(s(x1)), x1))))), s(+(x1, s(s(+(x1, *(s(s(x1)), x1))))))))

The TRS R consists of the following rules:

*(x, s(y)) → +(x, *(x, y))
*(x, 0) → 0
+(0, y) → y
+(s(x), y) → s(+(x, y))
-(x, 0) → x
-(s(x), s(y)) → -(x, y)

Q is empty.
We have to consider all (P,Q,R)-chains.